package models

import (
	"github.com/jinzhu/gorm"
)

var Conn *gorm.DB
/*
type DB interface {
	// InsertIp 存储IP
	InsertIP(ip *IP) error
	// CountIPs 统计数据库里IP总数量
	CountIP() (int64, error)
	// DeleteIP 删除指定IP
	DeleteIP(ip *IP) error
	// GetOneIP 获取指定的一个IP
	GetOneIP(ip string) (*IP, error)
	// GetAllIP 获取所有IP
	GetAllIP() ([]*IP, error)
	// 获取指定数量的ip
	GetNumIPWithType(int) ([]*IP, error)
	// FindIPWithType 通过类型获取IP
	FindIPWithType(typ string) ([]*IP, error)
	// UpdateToFirstIP 将指定IP更新到第一个位置的IP数据上
	//UpdateToFirstIP(ip *IP) error
	// 是否存在https的IP
	ExistHttps() (bool, error)
}

type DefaultDB struct {
	x *gorm.DB
}

func NewDefaultDB(x *gorm.DB) *DefaultDB {
	return &DefaultDB{
		x: x,
	}
}

func (d *DefaultDB) InsertIP(ip *IP) error {

	tx := d.x.Begin()
	if err := tx.Create(ip).Error; err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	return nil
}

func (d *DefaultDB) CountIP() (int64, error) {
	var count int64
	if err := d.x.Model(NewIP()).Where("id >= ?", 0).Count(&count).Error; err != nil {
		return count, err
	}
	return count, nil
}

func (d *DefaultDB) DeleteIP(ip *IP) (err error) {
	err = d.x.Where("id = ?", ip.ID).Error
	return
}

func (d *DefaultDB) GetOneIP(ip_data string) (ip *IP, err error) {
	ip = NewIP()
	if err := d.x.Where("data=?", ip_data).Find(ip).Error; err != nil {
		return nil, err
	}
	return
}

func (d *DefaultDB) GetAllIP() ([]*IP, error) {

	tmpIp := make([]*IP, 0)

	err := d.x.Where("speed <= 1000").Find(&tmpIp).Error
	if err != nil {
		return nil, err
	}
	return tmpIp, nil
}

func (d *DefaultDB) GetNumIPWithType(num int) ([]*IP, error) {
	temIp := make([]*IP, num)
	err := d.x.Order("speed asc").Limit(num).Find(&temIp).Error
	return temIp, err
}

func (d *DefaultDB) FindIPWithType(typ string) ([]*IP, error) {
	tmpIp := make([]*IP, 0)
	switch typ {
	case "http":
		err := d.x.Where("speed <= 1000 and type1=?", "http").Find(&tmpIp).Error
		if err != nil {
			return tmpIp, err
		}
	case "https":
		//test has https proxy on databases or not
		hasHttps, err := d.ExistHttps()
		if err != nil {
			return nil, err
		}
		if hasHttps == false {
			return tmpIp, nil
		}
		err = d.x.Where("speed <= 1000 and type2=?", "https").Find(&tmpIp).Error
		if err != nil {
			return tmpIp, err
		}
	default:
		return tmpIp, nil
	}

	return tmpIp, nil
}

func (d *DefaultDB) UpdateToFirstIP(ip *IP) error {
	err := d.x.Where("id=?", 1).Update(ip).Error
	if err != nil {
		return err
	}
	return nil
}

func (d *DefaultDB) ExistHttps() (bool, error) {
	ip := NewIP()
	err := d.x.Where("type2=?", "https").Find(ip).Error
	if err != nil {
		return false, err
	}

	return true, nil
}
*/